Hvad er operatøren “->” i C ++?

-> er ikke operatør. Det er faktisk to separate operatører - og>.
Betingelsens kode mindskes x, mens den returnerer xs oprindelige (ikke reducerede) værdi, og sammenligner derefter den oprindelige værdi med 0 ved hjælp af> operatoren.
For bedre at forstå kunne udsagnet skrives som følger:
mens ((x--)> 0)
|
Eller for noget helt andet ... x glider til 0.
mens (x - \
\
\
\
> 0)
printf ("% d", x);
Ikke så matematisk, men ... hvert billede tegner tusind ord ...
|
Det er en meget kompliceret operatør, så selv ISO / IEC JTC1 (Joint Technical Committee 1) placerede sin beskrivelse i to forskellige dele af C ++ - standarden.
Med sjov til side er de to forskellige operatorer: - og> beskrevet henholdsvis i §5.2.6 / 2 og §5.9 i C ++ 03-standarden.
|
Det svarer til
mens (x--> 0)
x-- (post decrement) svarer til x = x-1, så koden omdannes til:
mens (x> 0) {
x = x-1;
// logik
}
x--; // Indlægsnedgangen er udført, når x <= 0
|
x kan gå til nul endnu hurtigere i den modsatte retning:
int x = 10;
mens (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Du kan styre hastigheden med en pil!
int x = 100;
mens (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Det er det
# inkluderer 
int main (ugyldigt) {
int x = 10;
mens (x--> 0) {// x går til 0
printf ("% d", x);
}
returnere 0;
}
Bare pladsen får tingene til at se sjove ud - dekrementer og> sammenligner.
|
Anvendelsen af ​​-> har historisk relevans. Nedbrydning var (og er stadig i nogle tilfælde) hurtigere end at øge x86-arkitekturen. Brug -> antyder, at x går til 0 og appellerer til dem med matematisk baggrund.
|
mens (x--> 0)
er, hvordan det er analyseret.
|
Helt nørd, men jeg vil bruge dette:
#definer som; mens
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
gør printf ("n er% d \ n", n) som (n -> 0);
returnere 0;
}
|
En bog, jeg læste (jeg kan ikke huske korrekt, hvilken bog) sagde: Kompilatorer forsøger at analysere udtryk til det største symbol ved at bruge venstre højre regel.
I dette tilfælde udtrykket:
x -> 0
Parser til største poletter:
token 1: x
token 2: -
token 3:>
token 4: 0
konkluder: x--> 0
Den samme regel gælder for dette udtryk:
a ----- b
Efter analyse:
token 1: a
token 2: -
token 3: -
token 4: -
token 5: b
konkluder: (a -) - - b
Jeg håber dette hjælper med at forstå det komplicerede udtryk ^^
|
Dette er nøjagtigt det samme som
mens (x--)
{
printf ("% d", x);
}
for ikke-negative tal
|
Under alle omstændigheder har vi en "går til" -operatør nu. "->" er let at huske som en retning, og "mens x går til nul" betyder-lige.
Desuden er det lidt mere effektivt end "for (x = 10; x> 0; x -)" på nogle platforme.
|
Denne kode sammenligner først x og 0 og reduceres derefter x. (Også sagt i det første svar: Du efterdekrimenterer x og sammenligner derefter x og 0 med> operatøren.) Se output af denne kode:
9 8 7 6 5 4 3 2 1 0
Vi sammenligner nu først og reducerer derefter ved at se 0 i output.
Hvis vi først vil mindske og derefter sammenligne, skal du bruge denne kode:
# inkluderer 
int main (ugyldigt)
{
int x = 10;
mens (--x> 0) // x går til 0
{
printf ("% d", x);
}
returnere 0;
}
Denne output er:
9 8 7 6 5 4 3 2 1
|
Min kompilator udskriver 9876543210, når jeg kører denne kode.
# inkluderer 
int main ()
{
int x = 10;
mens (x -> 0) // x går til 0
{
std :: cout << x;
}
}
Som forventet. Tiden (x--> 0) betyder faktisk mens (x> 0). Dex - post-dekrementer x.
mens (x> 0)
{
x--;
std :: cout << x;
}
er en anden måde at skrive den samme ting på.
Det er rart, at originalen dog ligner "mens x går til 0".
|
Der mangler et mellemrum mellem - og>. x nedlægges efter post, dvs. reduceres efter kontrol af tilstanden x> 0?.
|
- er deklementsoperatøren og> er operatøren med større værdi.
De to operatører anvendes som en enkelt som ->.
|
Det er en kombination af to operatører. For det første - er til reduktion af værdien, og> er til kontrol af, om værdien er større end den højre operand.
# inkluderer 
int main ()
{
int x = 10;
mens (x--> 0)
printf ("% d", x);
returnere 0;
}
Outputtet vil være:
9 8 7 6 5 4 3 2 1 0
|
Faktisk er x efter-dekrementering, og med den betingelse kontrolleres. Det er ikke ->, det er (x--)> 0
Bemærk: Værdien af ​​x ændres, efter at betingelsen er kontrolleret, fordi den post-dekrementering. Nogle lignende tilfælde kan også forekomme, for eksempel:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C og C ++ overholder "maksimal munch" -reglen. På samme måde oversættes a --- b til (a--) - b, i dit tilfælde x -> 0 oversættes til (x -)> 0.
Hvad reglen i det væsentlige siger er, at udtryk fra venstre mod højre dannes ved at tage det maksimale antal tegn, der danner et gyldigt udtryk.
|
Hvorfor al komplikationen?
Det enkle svar på det originale spørgsmål er bare:
# inkluderer 
int main ()
{
int x = 10;
mens (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Det gør det samme. Jeg siger ikke, at du skal gøre det sådan, men det gør det samme og ville have besvaret spørgsmålet i et indlæg.
X-- er bare stenografi for ovenstående, og> er bare en normal større end operatør. Intet stort mysterium!
Der er for mange mennesker, der gør enkle ting komplicerede i dag;)
|
På den konventionelle måde ville vi definere en betingelse i mens sløjfeparentes () og en afsluttende tilstand inde i seler {}, men -> definerer begge på én gang.
For eksempel:
int abc (ugyldigt)
{
int a = 5
mens ((a--)> 0) // Reduktion og sammenligning begge på én gang
{
// Kode
}
}
Dette reducerer a og kører sløjfen, mens a er større end 0.
Konventionelt ville det være som:
int abc (ugyldigt)
{
int a = 5;
mens (a> 0)
{
en--;
// Kode
}
en--;
}
Begge veje gør vi det samme og opnår de samme mål.
|
(x -> 0) betyder (x--> 0).
Du kan bruge (x ->) Output: 9 8 7 6 5 4 3 2 1 0
Du kan bruge (- x> 0) Det er middel (--x> 0) Output: 9 8 7 6 5 4 3 2 1
Du kan bruge
(- \
\
x> 0)
Output: 9 8 7 6 5 4 3 2 1
Du kan bruge
(\
\
x -> 0)
Output: 9 8 7 6 5 4 3 2 1 0
Du kan bruge
(\
\
x -> 0
\
\
)
Output: 9 8 7 6 5 4 3 2 1 0
Du kan også bruge
(
x
->
)
Output: 9 8 7 6 5 4 3 2 1 0
På samme måde kan du prøve mange metoder til at udføre denne kommando med succes.
|
Her - er den unære operatør efter nedskrivning.
mens (x--> 0) // x går til 0
{
printf ("% d", x);
}
I begyndelsen vurderes tilstanden som
(x> 0) // 10> 0
Nu fordi betingelsen er sand, vil den gå ind i sløjfen med en reduceret værdi
x-- // x = 9
Derfor er den første trykte værdi 9
Og så videre. I den sidste sløjfe x = 1, så betingelsen er sand. Som pr. Den enlige operatør ændrede værdien sig til x = 0 på udskrivningstidspunktet.
Nu er x = 0, som evaluerer betingelsen (x> 0) som falsk, og mens loop løber ud.
|
Dette -> er slet ikke en operatør. Vi har en operatør som ->, men ikke som ->. Det er bare en forkert fortolkning af while (x--> 0), hvilket simpelthen betyder, at x har post-decrement-operatoren, og denne loop løber, indtil den er større end nul.
En anden enkel måde at skrive denne kode på ville være mens (x--). While-loop'en stopper, når den får en falsk tilstand, og her er der kun et tilfælde, dvs. 0. Så det stopper, når x-værdien reduceres til nul.
|
Meget aktivt spørgsmål. Optjen 10 omdømme for at besvare dette spørgsmål. Omdømmekravet hjælper med at beskytte dette spørgsmål mod spam og ikke-svar-aktivitet.
Er det ikke det svar, du leder efter? Gennemse andre spørgsmål mærket c ++ c operatører kodeformatering standarder-overholdelse eller stil dit eget spørgsmål.